
#include "headers/GlobalHeader.h"

//Variables Globales

t_Cola *colaPedidos;
pthread_mutex_t mutexListaPedidos, mutexColaSSTF;
pthread_mutex_t mutexArchivoMapeado;
pthread_mutex_t mutexCabezalActual;
Nodo *lista_pedidos=NULL;
Nodo *listaSSTF;
Nodo *fin_lista_pedidos = NULL;
t_nodoCola *listaNATrabajar = NULL;
//t_nodoCola *listaPedidosExtended = NULL;




//NodoNstep *lista_pedidosnstep=NULL;
//NodoNstep *fin_lista_pedidosnstep = NULL;
t_pedido pedidoPlanificacion;
char planificador[30];
int32_t filesize;
int32_t contador_msync, cantidadClientesPFS = 0;
struct_config configuracion;
PPD_CHS posicionActualCabezal, posicionAnterior, proximoSectorPlanifico;
sem_t *sem_lista, *enviePedido, *respuesta;
char* handlerArchivoMapeado;
extern t_log *logger;
int32_t modoInicio, tipoPedido, algoritmoUtilizado;
char *sectoresRecorridos;
int32_t *colaDePedidos, sizeCola, sizeListaNSTEP;
protocoloTRACE_respuesta *respuestaTRACE;
protocoloCLEAN_respuesta *respuestaCLEAN;
int32_t discoEstaSubiendo = 1;
int32_t *sectores;
int32_t cantidadTotalPedidos=0;
NodoPFS *listaPFS = NULL ;
int32_t N =0;

//SOCKET DESCRIPTOR CONSOLA
extern int32_t sd;

//prototipo de funciones

int32_t *armarColaLogueoSSTF();
int32_t *armarColaLogueoNSTEP();
char *armarSectoresRecorridosLogueo(int32_t *ptrSectoresRecorridos, int32_t cantidadSectores);
void cargoModosInicio();
void thread_agrego_pedidos(void *parametro);
void armarSectoresSolicitados (int32_t *ptrSectoresRecorridos, int32_t cantidadSectoresRecorridos);
nipc procesoPedidoSSTF(t_pedido pedidoPorProcesar, int32_t *colaLoguear);
nipc procesoPedidoNSTEPSCAN(t_pedido pedidoPorProcesar, int32_t *colaLoguear, int32_t N);
int32_t tamanioLista();
void enviaRespuestaTRACE(PPD_CHS posicionActualCabezal,PPD_CHS  posicionAnterior, int32_t sectorPlanificado);
void enviaRespuestaCLEAN(int32_t valorClean);
void logueoInformacionProceso(t_pedido pedidoPorProcesar, int32_t *cola);
void imprimirProximoSector();
void agarroNPedidos(t_nodoCola ** listaNATrabajar,int32_t *N);


int main(void)
{
	struct_thread_lector struct_thread_lector, struct_thread_lector_consola;
	pthread_t thread_lectorPedidos_pfs_id, thread_lectorPedidos_raid_id, thread_cliente_pfs_id, thread_planificador, thread_msync_id, thread_lector_consola_id;
	int32_t addrlen = sizeof(struct sockaddr_in);
	int32_t cliente_ppd = socket(AF_INET,SOCK_STREAM,0);
	int32_t socket_server_pfs = socket(AF_INET,SOCK_STREAM,0);
	int32_t cliente_pfs, rc, i, var2;
	fd_set sockets_pfs, sockets_select;
	int32_t cantidadSectores, valorClean;
	int32_t *sectores;
	t_stream *streamEnvio;
	nipc nipcConsola;
	int32_t *colaLogueo;
	int32_t jojo=0;

	//CARGO EN EL STRUCT DEL CONFIG LA INFORMACION DEL ARCHIVO DE CONFIGURACION
	configuracion = cargaConfiguracionInicial();

	//INICIALIZO LAS ESTRUCTURAS QUE SE VAN A USAR MAS ADELANTE
	inicializarEstructuras();

	//CREO LA COLA DE PEDIDOS
	colaPedidos = crearCola();

	//LOGUEO INICIALIZACION DEL DISCO
	if (configuracion.LogActivado==1)
		log_info(logger, "MAIN", "Se inicio el disco: %s con un tamaño de %i bytes\n", configuracion.DiscoID, filesize);

	int32_t clientes_pfs[configuracion.cantClientesMaxPFS];
	int32_t descriptor_maximo = 0,a, respuesta;
	nipc paquete_mando,paquete_recibo;

	//CREO THREAD DE SINCRONIZACION, TANTO PARA LISTEN COMO PARA CONNECT
	pthread_create(&thread_msync_id,NULL,(void*)&thread_msync,NULL);

	struct_thread_lector_consola.lista = &lista_pedidos;
	struct_thread_lector_consola.lista = &lista_pedidos;
	struct_thread_lector_consola.socket_id = cliente_ppd;

	//CREO THREAD LECTOR PEDIDOS DE CONSOLA, TANTO PARA LISTEN COMO PARA CONNECT
	pthread_create(&thread_lector_consola_id,NULL,(void *)&thread_lector_consola,(void *)&struct_thread_lector_consola);

	//INICIO SEMAFOROS Y MUTEX
	pthread_mutex_init (&mutexListaPedidos, NULL);
	pthread_mutex_init (&mutexArchivoMapeado, NULL);
	pthread_mutex_init(&mutexColaSSTF, NULL);
	pthread_mutex_init (&mutexCabezalActual, NULL);

	//sem_init(&sem_lista,0,0);
	sem_init(&enviePedido, 0, 0);
	sem_init(&respuesta, 0, 0);

	struct sockaddr_in *direccion_local = malloc(sizeof(struct sockaddr_in));
	struct sockaddr_in *direccion_remota = malloc(sizeof(struct sockaddr_in));

	//SEGUN EL MODO DE INICIO
	switch (modoInicio)
	{
	case CONNECT: //me voy a conectar al RAID

		direccion_local->sin_family = AF_INET;
		direccion_local->sin_addr.s_addr = INADDR_ANY;
		direccion_local->sin_port = htons(configuracion.PuertoEscuchaPpd);

		direccion_remota->sin_family = AF_INET;
		direccion_remota->sin_addr.s_addr = inet_addr(configuracion.IPRaid);
		direccion_remota->sin_port = htons(configuracion.PuertoRaid);

		//puts("me voy a conectar");
		rc = connect(cliente_ppd,(struct sockaddr *)direccion_remota,addrlen);
		if (rc < 0)
		{
			//LOGUEO EL ERROR DE CONNECT
			if (configuracion.LogActivado==1)
				log_error(logger, "MAIN", "%s: Error al intentar conectarse al RAID a traves del socket %i \n", cliente_ppd);
			close(cliente_ppd);
			cerrarArchivo();
			exit(1);
		}

		if (configuracion.LogActivado==1)
			log_info(logger, "MAIN", "Se conecto el RAID a traves del socket: %i \n", cliente_ppd);

		//PREPARO EL HANDSHAKE
		paquete_mando.type = 0;
		paquete_mando.payloadlength = sizeof(t_pedido);
		strcpy(paquete_mando.payload.planificador_id,configuracion.DiscoID);
		paquete_mando.payload.direccionSector = cantidadTotalDeSectores();

		rc = send(cliente_ppd,&paquete_mando,sizeof(nipc),0);
		if (rc < 0)
		{
			if (configuracion.LogActivado == 1)
				log_error(logger, "MAIN", "Error al enviar Handshake \n");
			cerrarArchivo();
			exit(1);
		}
		if (configuracion.LogActivado == 1)
			log_info(logger, "MAIN", "Se mando handshake \n");

		rc = recv(cliente_ppd,&paquete_recibo,sizeof(nipc),0);
		if (rc < 0)
		{
			if (configuracion.LogActivado == 1)
				log_error(logger, "MAIN", "Error al recibir handshake \n");
			exit (1);
		}

		if(paquete_recibo.payloadlength == 0)
		{
			struct_thread_lector.lista = &lista_pedidos;
			//struct_thread_lector.lista = &lista_pedidos;
			struct_thread_lector.socket_id = cliente_ppd;
			if (configuracion.LogActivado == 1)
				log_info(logger, "MAIN", "Se recibio el handshake correctamente \n");
		}

		pthread_create(&thread_lectorPedidos_raid_id,NULL,(void*)&thread_lector_pedidos_raid,(void *)&struct_thread_lector);

		switch (algoritmoUtilizado)
		{
		case CON_INANICION:
			while(TRUE)
			{
				sem_getvalue(&colaPedidos->cantidadPedidos, &sizeCola);
				//MIENTRAS HAYA PEDIDOS EN LA COLA, LOS VOY A PROCESAR
				if (sizeCola > 0)
				{
					//PIDO LOS SECTORES DE LA COLA PARA LOGUEARLOS
					//BLOQUEO LA LISTA PARA PODER TRABAJAR
					pthread_mutex_lock (&mutexListaPedidos);
					//SACO UN PEDIDO DE LA COLA PARA PROCESARLO, ACA LA FUNCION SE LLAMARIA TOMOPEDIDO();
					colaLogueo = armarColaLogueoSSTF();
					pedidoPlanificacion = quitarPedido_cola();
					pthread_mutex_unlock (&mutexListaPedidos);

					//UNA VEZ QUE TOME EL PEDIDO, YA PUEDO LIBERAR LA COLA PARA QUE SE AGREGUEN MAS PEDIDOS DE LOS OTROS THREADS
					//TENGO QUE VER EL TIPO DE PEDIDO, SI ES DE CONSOLA O SI ES DE PFS
					switch(pedidoPlanificacion.conexion_pfs_id)
					{
					case PEDIDO_CONSOLA:
						//SI ES DE CONSOLA, PROCESO Y AVISO QUE FUE PROCESADO ASI PUEDO DEVOLVER POR STDOUT
						//DENTRO DE ESTA FUNCION, DEBE ESTAR LA ENCARGADA DE LEER Y ESCRIBIR EN DISCO
						nipcConsola = procesoPedidoSSTF(pedidoPlanificacion, colaLogueo);
						free(colaLogueo);
						switch (pedidoPlanificacion.lectura_o_escritura)
						{
						case 'L' : //sos trace
							enviaRespuestaTRACE(posicionActualCabezal, posicionAnterior, pedidoPlanificacion.direccionSector);
							break;

						case 'E' : //sos clean
							enviaRespuestaCLEAN(nipcConsola.type);
							if (configuracion.LogActivado == 1)
								log_info(logger, "MAIN", "Se envio la respuesta del pedido de E sobre el sector %d:%d correctamente \n", posicionActualCabezal.cylinder, posicionActualCabezal.sector);
							break;
						}
						break;
						default:
							//SI ES DE PFS, O SEA, SI ES DISTRIBUIDO POR EL RAID
							//DENTRO DE ESTA FUNCION, DEBE ESTAR LA ENCARGADA DE LEER Y ESCRIBIR EN DISCO
							paquete_mando = procesoPedidoSSTF(pedidoPlanificacion, colaLogueo);
							free(colaLogueo);
							send(cliente_ppd,&paquete_mando,sizeof(nipc),0);
							if (configuracion.LogActivado == 1)
								log_info(logger, "MAIN", "Se envio la respuesta del pedido de E sobre el sector %d:%d correctamente \n", posicionActualCabezal.cylinder, posicionActualCabezal.sector);
							break;
					}
				}
			}
			break;
		case SIN_INANICION:

			while(TRUE)
			{
				sem_getvalue(&(colaPedidos->cantidadPedidos), &sizeCola);

				if (sizeCola > 0)
				{

					N=0;
					pthread_mutex_lock (&mutexListaPedidos);
					listaNATrabajar=NULL;
					agarroNPedidos(&listaNATrabajar,&N);

					pthread_mutex_unlock (&mutexListaPedidos);

					while(N>0){

							if(listaNATrabajar != NULL){

							pthread_mutex_lock (&mutexListaPedidos);
							if (configuracion.LogActivado == 1)
								colaLogueo = armarColaLogueoSSTF();

							pedidoPlanificacion = ppd_nstepScan(N);

							pthread_mutex_unlock (&mutexListaPedidos);

							sem_getvalue(&(colaPedidos->cantidadPedidos), &sizeCola);
							N--;
							switch(pedidoPlanificacion.conexion_pfs_id)
							{
							case PEDIDO_CONSOLA:

								nipcConsola = procesoPedidoNSTEPSCAN(pedidoPlanificacion, colaLogueo, N);

								if (configuracion.LogActivado == 1)
									free(colaLogueo);
								switch (pedidoPlanificacion.lectura_o_escritura)
								{
								case 'L' : //sos trace
									enviaRespuestaTRACE(posicionActualCabezal, posicionAnterior, pedidoPlanificacion.direccionSector);
									if (configuracion.LogActivado == 1)
										log_info(logger, "MAIN", "Se envio la respuesta del pedido de E sobre el sector %d:%d correctamente \n", posicionActualCabezal.cylinder, posicionActualCabezal.sector);
									break;

								case 'E' : //sos clean
									enviaRespuestaCLEAN(nipcConsola.type);
									if (configuracion.LogActivado == 1)
										log_info(logger, "MAIN", "Se envio la respuesta del pedido de E sobre el sector %d:%d correctamente \n", posicionActualCabezal.cylinder, posicionActualCabezal.sector);
									break;
								}
								break;
								default:
									//SI ES DE PFS, O SEA, SI ES DISTRIBUIDO POR EL RAID
									//DENTRO DE ESTA FUNCION, DEBE ESTAR LA ENCARGADA DE LEER Y ESCRIBIR EN DISCO
									//paquete_mando = procesoPedidoNSTEPSCAN(pedidoPlanificacion, colaLogueo, N - var2 -1);
									paquete_mando = procesoPedidoNSTEPSCAN(pedidoPlanificacion, colaLogueo, N);
									if (configuracion.LogActivado == 1)
										free(colaLogueo);
									//puts("me quede en un send");
									send(cliente_ppd,&paquete_mando,sizeof(nipc),0);
									if (configuracion.LogActivado == 1)
										log_info(logger, "MAIN", "Se envio la respuesta del pedido de %c sobre el sector %d:%d correctamente \n",paquete_mando.payload.lectura_o_escritura, posicionActualCabezal.cylinder, posicionActualCabezal.sector);
									//printf(" <%i> ", paquete_mando.payload.direccionSector);
									break;
							}
						}
					}
				}
			}
			break;
		}
		break;

		case LISTEN:

			struct_thread_lector.lista = &lista_pedidos;
			struct_thread_lector.lista = &lista_pedidos;

			pthread_create(&thread_lectorPedidos_pfs_id,NULL,(void*)&thread_lector_pedidos_pfs,(void *)&struct_thread_lector);

			switch (algoritmoUtilizado)
			{
			case CON_INANICION:
				while(TRUE)
				{
					sem_getvalue(&colaPedidos->cantidadPedidos, &sizeCola);

					//MIENTRAS HAYA PEDIDOS EN LA COLA, LOS VOY A PROCESAR
					if (sizeCola > 0)
					{
						//PIDO LOS SECTORES DE LA COLA PARA LOGUEARLOS
						//BLOQUEO LA LISTA PARA PODER TRABAJAR
						pthread_mutex_lock (&mutexListaPedidos);
						//SACO UN PEDIDO DE LA COLA PARA PROCESARLO, ACA LA FUNCION SE LLAMARIA TOMOPEDIDO();
						colaLogueo = armarColaLogueoSSTF();
						pedidoPlanificacion = quitarPedido_cola();
						pthread_mutex_unlock (&mutexListaPedidos);

						//UNA VEZ QUE TOME EL PEDIDO, YA PUEDO LIBERAR LA COLA PARA QUE SE AGREGUEN MAS PEDIDOS DE LOS OTROS THREADS
						//TENGO QUE VER EL TIPO DE PEDIDO, SI ES DE CONSOLA O SI ES DE PFS
						switch(pedidoPlanificacion.conexion_pfs_id)
						{
						case PEDIDO_CONSOLA:
							//SI ES DE CONSOLA, PROCESO Y AVISO QUE FUE PROCESADO ASI PUEDO DEVOLVER POR STDOUT
							//DENTRO DE ESTA FUNCION, DEBE ESTAR LA ENCARGADA DE LEER Y ESCRIBIR EN DISCO
							nipcConsola = procesoPedidoSSTF(pedidoPlanificacion, colaLogueo);
							free(colaLogueo);
							switch (pedidoPlanificacion.lectura_o_escritura)
							{
							case 'L' : //sos trace
								enviaRespuestaTRACE(posicionActualCabezal, posicionAnterior, pedidoPlanificacion.direccionSector);
								if (configuracion.LogActivado == 1)
									log_info(logger, "MAIN", "Se envio la respuesta del pedido de L sobre el sector %d:%d correctamente \n", posicionActualCabezal.cylinder, posicionActualCabezal.sector);
								break;

							case 'E' : //sos clean
								enviaRespuestaCLEAN(nipcConsola.type);
								if (configuracion.LogActivado == 1)
									log_info(logger, "MAIN", "Se envio la respuesta del pedido de E sobre el sector %d:%d correctamente \n", posicionActualCabezal.cylinder, posicionActualCabezal.sector);
								break;
							}
							break;
							default:
								//SI ES DE PFS, O SEA, SI ES DISTRIBUIDO POR EL RAID
								//DENTRO DE ESTA FUNCION, DEBE ESTAR LA ENCARGADA DE LEER Y ESCRIBIR EN DISCO
								paquete_mando = procesoPedidoSSTF(pedidoPlanificacion, colaLogueo);
								free(colaLogueo);
								send(pedidoPlanificacion.conexion_pfs_id,&paquete_mando,sizeof(nipc),0);
								//pthread_mutex_unlock(&mutexListaPedidos);
								break;
						}
					}
				}
				break;

			case SIN_INANICION:
//				while(TRUE)
//					{
//						sem_getvalue(&sem_lista, &sizeListaNSTEP);
//						if (sizeListaNSTEP > 0)
//						{
//							//ESPERO A QUE ENTREN PEDIDOS
//							sem_wait(&sem_lista);
//							//BLOQUEO LA LISTA PARA PODER TRABAJAR
//							pthread_mutex_lock (&mutexListaPedidos);
//							//SACO UN PEDIDO DE LA LISTA PARA PROCESARLO
//							colaLogueo = armarColaLogueoNSTEP();
//							//pedidoPlanificacion = ppd_nstepScan(&lista_pedidosnstep);
//
//							//pedidoPlanificacion = ppd_nstepScan();
//							pthread_mutex_unlock(&mutexListaPedidos);
//							//TENGO QUE VER EL TIPO DE PEDIDO, SI ES DE CONSOLA O SI ES DE PFS
//							switch(pedidoPlanificacion.conexion_pfs_id)
//							{
//							case PEDIDO_CONSOLA:
//								//nipcConsola = procesoPedidoNSTEPSCAN(pedidoPlanificacion, colaLogueo);
//								free(colaLogueo);
//								switch (pedidoPlanificacion.lectura_o_escritura)
//								{
//								case 'L' : //sos trace
//									enviaRespuestaTRACE(posicionActualCabezal, posicionAnterior, pedidoPlanificacion.direccionSector);
//									if (configuracion.LogActivado == 1)
//										log_info(logger, "MAIN", "Se envio la respuesta del pedido de L sobre el sector %d:%d correctamente \n", posicionActualCabezal.cylinder, posicionActualCabezal.sector);
//									break;
//
//								case 'E' : //sos clean
//									enviaRespuestaCLEAN(nipcConsola.type);
//									if (configuracion.LogActivado == 1)
//										log_info(logger, "MAIN", "Se envio la respuesta del pedido de E sobre el sector %d:%d correctamente \n", posicionActualCabezal.cylinder, posicionActualCabezal.sector);
//									break;
//								}
//								break;
//								default:
//									//SI ES DE PFS, O SEA, SI ES DISTRIBUIDO POR EL RAID
//									//DENTRO DE ESTA FUNCION, DEBE ESTAR LA ENCARGADA DE LEER Y ESCRIBIR EN DISCO
//									//paquete_mando = procesoPedidoNSTEPSCAN(pedidoPlanificacion, colaLogueo);
//									free(colaLogueo);
//									send(pedidoPlanificacion.conexion_pfs_id,&paquete_mando,sizeof(nipc),0);
//									if (configuracion.LogActivado == 1)
//										log_info(logger, "MAIN", "Se envio la respuesta del pedido de E sobre el sector %d:%d correctamente \n", posicionActualCabezal.cylinder, posicionActualCabezal.sector);
//									break;
//							}
//						}
//					}
				while(TRUE)
				{
					sem_getvalue(&(colaPedidos->cantidadPedidos), &sizeCola);

					if (sizeCola > 0)
					{

						N=0;
						pthread_mutex_lock (&mutexListaPedidos);
						listaNATrabajar=NULL;
						agarroNPedidos(&listaNATrabajar,&N);

						pthread_mutex_unlock (&mutexListaPedidos);

						while(N>0){

								if(listaNATrabajar != NULL){

								pthread_mutex_lock (&mutexListaPedidos);
								if (configuracion.LogActivado == 1)
									colaLogueo = armarColaLogueoSSTF();

								pedidoPlanificacion = ppd_nstepScan(N);

								pthread_mutex_unlock (&mutexListaPedidos);

								sem_getvalue(&(colaPedidos->cantidadPedidos), &sizeCola);
								N--;
								switch(pedidoPlanificacion.conexion_pfs_id)
								{
								case PEDIDO_CONSOLA:

									nipcConsola = procesoPedidoNSTEPSCAN(pedidoPlanificacion, colaLogueo, N);

									if (configuracion.LogActivado == 1)
										free(colaLogueo);
									switch (pedidoPlanificacion.lectura_o_escritura)
									{
									case 'L' : //sos trace
										enviaRespuestaTRACE(posicionActualCabezal, posicionAnterior, pedidoPlanificacion.direccionSector);
										if (configuracion.LogActivado == 1)
											log_info(logger, "MAIN", "Se envio la respuesta del pedido de E sobre el sector %d:%d correctamente \n", posicionActualCabezal.cylinder, posicionActualCabezal.sector);
										break;

									case 'E' : //sos clean
										enviaRespuestaCLEAN(nipcConsola.type);
										if (configuracion.LogActivado == 1)
											log_info(logger, "MAIN", "Se envio la respuesta del pedido de E sobre el sector %d:%d correctamente \n", posicionActualCabezal.cylinder, posicionActualCabezal.sector);
										break;
									}
									break;
									default:
										//SI ES DE PFS, O SEA, SI ES DISTRIBUIDO POR EL RAID
										//DENTRO DE ESTA FUNCION, DEBE ESTAR LA ENCARGADA DE LEER Y ESCRIBIR EN DISCO
										//paquete_mando = procesoPedidoNSTEPSCAN(pedidoPlanificacion, colaLogueo, N - var2 -1);
										paquete_mando = procesoPedidoNSTEPSCAN(pedidoPlanificacion, colaLogueo, N);
										if (configuracion.LogActivado == 1)
											free(colaLogueo);
										//puts("me quede en un send");
										send(pedidoPlanificacion.conexion_pfs_id,&paquete_mando,sizeof(nipc),0);
										if (configuracion.LogActivado == 1)
											log_info(logger, "MAIN", "Se envio la respuesta del pedido de %c sobre el sector %d:%d correctamente \n",paquete_mando.payload.lectura_o_escritura, posicionActualCabezal.cylinder, posicionActualCabezal.sector);
										//printf(" <%i> ", paquete_mando.payload.direccionSector);
										break;
								}
							}
						}
					}
				}
				break;
			}
			break;
	}

	destruirCola();

	close(cliente_ppd);
	return 0;
}

nipc procesoPedidoSSTF(t_pedido pedidoPorProcesar, int32_t *colaLoguear)
{
	nipc nipcConsola = armoNIPC(pedidoPorProcesar);
	t_pedido pedido;

	pthread_mutex_lock (&mutexListaPedidos);
	proximoSectorPlanifico = tomarPedido_cola();
	pthread_mutex_unlock (&mutexListaPedidos);

	logueoInformacionProceso(pedidoPorProcesar, colaLoguear);

	posicionAnterior = posicionActualCabezal;
	posicionActualCabezal = ppd_LBAToCHS(pedidoPorProcesar.direccionSector);

	if (configuracion.LogActivado == 1)
		log_info(logger, "MAIN", "Se proceso el pedido de %c sobre el sector %d:%d correctamente \n", pedidoPorProcesar.lectura_o_escritura, posicionActualCabezal.cylinder, posicionActualCabezal.sector);

	return nipcConsola;
}

nipc procesoPedidoNSTEPSCAN(t_pedido pedidoPorProcesar, int32_t *colaLoguear, int32_t N)
{
	nipc nipcConsola = armoNIPC(pedidoPorProcesar);
	t_pedido pedido;


	if(N>0 && listaNATrabajar != NULL){
		pthread_mutex_lock (&mutexListaPedidos);
		pedido = ppd_nstepScanProximoSector(N);
		proximoSectorPlanifico = ppd_LBAToCHS(pedido.direccionSector);
		pthread_mutex_unlock(&mutexListaPedidos);
	}
	if (configuracion.LogActivado == 1)
	logueoInformacionProceso(pedidoPorProcesar, colaLoguear);

	pthread_mutex_lock (&mutexCabezalActual);
	posicionAnterior = posicionActualCabezal;
	posicionActualCabezal = ppd_LBAToCHS(pedidoPorProcesar.direccionSector);
	pthread_mutex_unlock (&mutexCabezalActual);
	if (configuracion.LogActivado == 1)
	log_info(logger, "MAIN", "Se proceso el pedido de %c sobre el sector %d:%d correctamente \n", pedidoPorProcesar.lectura_o_escritura, posicionActualCabezal.cylinder, posicionActualCabezal.sector);

	return nipcConsola;
}

int32_t tamanioLista()
{
	int32_t resultado;
	Nodo *aux;

	aux = lista_pedidos;
	resultado = 0;

	while(aux != NULL)
	{
		aux = aux->sig;
		resultado++;
	}

	return resultado;
}

int32_t *armarColaLogueoSSTF()
{
	int32_t *resultado;
	int32_t current = 0;
	int32_t tamanio = 0;
	int32_t i = 0, j  = 0;
	t_nodoCola *aux;

	aux = colaPedidos->frente;
	//aux = listaNATrabajar;
	sem_getvalue(&colaPedidos->cantidadPedidos, &tamanio);
	//tamanio = sizeCola;
	//printf("asdf %i asdf",tamanio);
	//puts("llegue?");
	if(tamanio <= 6)
	{
		resultado = malloc(sizeof(int32_t)*tamanio);

		while (aux != NULL && i <= tamanio)
		{
			int32_t valorAgrego = aux->pedido.direccionSector;
			memcpy(resultado + current, &valorAgrego, sizeof(int32_t));
			current++;
			i++;
			aux = aux->siguiente;
		}
	}
	else
	{
		resultado = malloc(sizeof(int32_t)*6);

		i = 0;
		//puts("toy x aca");
		while(aux != NULL)
		{
			if (i < 3)
			{
				//puts("toy x aca1");
				while(i < 3 && aux != NULL)
				{
					//puts("toy x aca1");
					int32_t valorAgrego = aux->pedido.direccionSector;
					memcpy(resultado + current, &valorAgrego, sizeof(int32_t));
					current++;
					aux = aux->siguiente;
					i++;
				}
			}
			else
			{
				//puts("toy x aca2");
				if(i >= tamanio - 3)
				{
					//puts("toy x aca2");
					for (j = i; j<tamanio; j++)
					{
						//puts("toy x ac4");
						int32_t valorAgrego = aux->pedido.direccionSector;
						memcpy(resultado + current, &valorAgrego, sizeof(int32_t));
						current++;
						aux = aux->siguiente;
					}
				}
				else
				{
					//puts("toy x aca3");
					aux = aux->siguiente;
					i++;
				}
			}
		}
	}
	//puts("pase?");
	return resultado;
}


int32_t *armarColaLogueoNSTEP()
{
	int32_t *resultado;
	int32_t current = 0;
	int32_t tamanio = 0;
	int32_t i = 0, j  = 0;
	int32_t pedidosActuales=0;
	NodoNstep *auxNstep;
	Nodo *auxNodo;

	pedidosActuales = sizeListaNSTEP;

	//auxNstep = lista_pedidosnstep;
	auxNodo = auxNstep->pedidos;

	if(pedidosActuales<=6){
		int32_t primeros6=0;
		resultado = malloc(sizeof(int32_t)*pedidosActuales);

		while( primeros6 != pedidosActuales){
			if(auxNodo != NULL){

				if(auxNodo->sig != NULL){

					int32_t valorAgrego = auxNodo->structPedidos.direccionSector;
					memcpy(resultado + current, &valorAgrego, sizeof(int32_t));
					current++;
					auxNodo = auxNodo->sig;
					primeros6++;
				}else{
					int32_t valorAgrego = auxNodo->structPedidos.direccionSector;
					memcpy(resultado + current, &valorAgrego, sizeof(int32_t));
					current++;
					primeros6++;
					if(primeros6 != pedidosActuales){
						auxNstep=auxNstep->sig;
						auxNodo = auxNstep->pedidos;
					}

				}

			}else{
				auxNstep=auxNstep->sig;
				auxNodo = auxNstep->pedidos;
			}

		}


	}else{
		int32_t primeros3=0;
		resultado = malloc(sizeof(int32_t)*6);
		int32_t ultimos3=0;
		int32_t diferencia=0;



		//Obtengo los primeros 3 sectores
		while( primeros3 != 3){
			if(auxNodo != NULL){

				if(auxNodo->sig != NULL){

					int32_t valorAgrego = auxNodo->structPedidos.direccionSector;
					memcpy(resultado + current, &valorAgrego, sizeof(int32_t));
					current++;
					auxNodo = auxNodo->sig;
					primeros3++;
				}else{
					int32_t valorAgrego = auxNodo->structPedidos.direccionSector;
					memcpy(resultado + current, &valorAgrego, sizeof(int32_t));
					current++;
					primeros3++;
					auxNstep=auxNstep->sig;
					auxNodo = auxNstep->pedidos;
				}

			}else{
				auxNstep=auxNstep->sig;
				auxNodo = auxNstep->pedidos;
			}

		}

		diferencia=pedidosActuales-primeros3-3;



		//Voy hasta los ultimos 3
		for (i=0;i<(diferencia);i++){

			if(auxNodo != NULL){

				if(auxNodo->sig != NULL){
					auxNodo = auxNodo->sig;
				}else{
					auxNstep=auxNstep->sig;
					auxNodo = auxNstep->pedidos;
				}

			}else{
				auxNstep=auxNstep->sig;
				auxNodo = auxNstep->pedidos;
			}

		}

		while( ultimos3 != 3){
			if(auxNodo != NULL){

				int32_t valorAgrego = auxNodo->structPedidos.direccionSector;
				memcpy(resultado + current, &valorAgrego, sizeof(int32_t));
				current++;
				auxNodo = auxNodo->sig;
				ultimos3++;

			}
			else{
				auxNstep=auxNstep->sig;
				auxNodo = auxNstep->pedidos;
			}

		}

	}
	return resultado;
}

void enviaRespuestaTRACE(PPD_CHS actual,PPD_CHS  anterior, int32_t sectorPlanificado)
{
	int32_t cantidadSectores, rc;
	int32_t *sectores;
	t_stream *streamEnvio;

	cantidadSectores = diferenciaEntreSectores(anterior,actual);

	sectores = SectoresRecorro(anterior,actual);

	respuestaTRACE = (protocoloTRACE_respuesta*)malloc(sizeof(protocoloTRACE_respuesta));
	respuestaTRACE->cabecera.type = TRACE1;
	respuestaTRACE->payload.posicionActual = ppd_CHStoLBA(anterior);
	respuestaTRACE->payload.sectorSolicitado = sectorPlanificado;
	respuestaTRACE->payload.tiempoConsumido = tiempoEntreSectores(anterior,actual);
	respuestaTRACE->sectoresRecorridos = malloc(cantidadSectores*sizeof(int32_t));
	respuestaTRACE->payload.proximoSector = proximoSectorAPlanificar();
	memcpy(respuestaTRACE->sectoresRecorridos, sectores, cantidadSectores*sizeof(int32_t));
	respuestaTRACE->cabecera.payloadlength = sizeof(respuestaTRACE->payload) + cantidadSectores*sizeof(int32_t);

	streamEnvio = RespuestaTRACE_serializer(respuestaTRACE, cantidadSectores);

	rc = send(sd, streamEnvio->data, streamEnvio->length, 0);

	free(respuestaTRACE->sectoresRecorridos);
	free(respuestaTRACE);
	free(streamEnvio);

}

void enviaRespuestaCLEAN(int32_t valorClean)
{
	t_stream *streamEnvio;
	int32_t rc;

	respuestaCLEAN = malloc(sizeof(protocoloCLEAN_respuesta));
	respuestaCLEAN->cabecera.type = CLEAN;
	respuestaCLEAN->cabecera.payloadlength = sizeof(int32_t);
	respuestaCLEAN->respuestaClean = valorClean;

	streamEnvio = RespuestaCLEAN_serializer(respuestaCLEAN);

	rc = send(sd, streamEnvio->data, streamEnvio->length, 0);
	if (rc < 0)
	{
		perror("send() failed");
	}

	free(respuestaCLEAN);
	free(streamEnvio);
}

void logueoInformacionProceso(t_pedido pedidoPorProcesar, int32_t *colaLogueo)
{
	//int32_t *sectores;
	//char *sectoresRecorridos;
	PPD_CHS sectorPedido1, sectorPedido2, sectorPedido3, sectorPedido4, sectorPedido5, sectorPedido6;

	if (configuracion.LogActivado==1){

//		switch (algoritmoUtilizado)
//		{
//		case CON_INANICION :
			switch(sizeCola)
			{
			case 1 :
				sectorPedido1 = ppd_LBAToCHS(colaLogueo[0]);
				log_info(logger, "procesoPedido", "Cola de Pedidos: [ %i:%i ] Tamaño: %i\n", sectorPedido1.cylinder, sectorPedido1.sector, sizeCola);
				log_info(logger, "procesoPedido", "Posicion Actual: %i:%i\n", posicionActualCabezal.cylinder, posicionActualCabezal.sector);
				sectorPedido1 = ppd_LBAToCHS(pedidoPorProcesar.direccionSector);
				log_info(logger, "procesoPedido", "Sector Solicitado: %i:%i\n", sectorPedido1.cylinder, sectorPedido1.sector);

				//ESTA FUNCION ME DEVUELVE UN ARRAY CON LOS SECTORES QUE RECORRO PARA LLEGAR AL SECTOR QUE SE VA A PROCESAR
				sectores = SectoresRecorro(posicionActualCabezal, sectorPedido1);

				//ESTA FUNCION CONVIERTE EL ARRAY DE INTS A CHAR* PARA SER LOGUEADO
				sectoresRecorridos = armarSectoresRecorridosLogueo(sectores, diferenciaEntreSectores(posicionActualCabezal, sectorPedido1));
				log_info(logger, "procesoPedido", "Sectores Recorridos: %s\n", sectoresRecorridos);
				log_info(logger, "procesoPedido", "Tiempo consumido: %f ms\n", tiempoEntreSectores(posicionActualCabezal, sectorPedido1));
				imprimirProximoSector();

				free(sectores);
				free(sectoresRecorridos);

				break;

			case 2 :
				sectorPedido1 = ppd_LBAToCHS(colaLogueo[0]);
				sectorPedido2 = ppd_LBAToCHS(colaLogueo[1]);
				log_info(logger, "procesoPedido", "Cola de Pedidos: [ %i:%i, %i:%i ] Tamaño: %i\n", sectorPedido1.cylinder, sectorPedido1.sector, sectorPedido2.cylinder, sectorPedido2.sector, sizeCola);
				log_info(logger, "procesoPedido", "Posicion Actual: %i:%i\n", posicionActualCabezal.cylinder, posicionActualCabezal.sector);
				sectorPedido1 = ppd_LBAToCHS(pedidoPorProcesar.direccionSector);
				log_info(logger, "procesoPedido", "Sector Solicitado: %i:%i\n", sectorPedido1.cylinder, sectorPedido1.sector);
				sectores = SectoresRecorro(posicionActualCabezal, sectorPedido1);
				sectoresRecorridos = armarSectoresRecorridosLogueo(sectores, diferenciaEntreSectores(posicionActualCabezal, sectorPedido1));
				log_info(logger, "procesoPedido", "Sectores Recorridos: %s\n", sectoresRecorridos);
				log_info(logger, "procesoPedido", "Tiempo consumido: %f ms\n", tiempoEntreSectores(posicionActualCabezal, sectorPedido1));
				imprimirProximoSector();

				free(sectores);
				free(sectoresRecorridos);
				break;
			case 3:
				sectorPedido1 = ppd_LBAToCHS(colaLogueo[0]);
				sectorPedido2 = ppd_LBAToCHS(colaLogueo[1]);
				sectorPedido3 = ppd_LBAToCHS(colaLogueo[2]);
				log_info(logger, "procesoPedido", "Cola de Pedidos: [ %i:%i, %i:%i, %i:%i ] Tamaño: %i\n", sectorPedido1.cylinder, sectorPedido1.sector, sectorPedido2.cylinder, sectorPedido2.sector, sectorPedido3.cylinder, sectorPedido3.sector, sizeCola);
				log_info(logger, "procesoPedido", "Posicion Actual: %i:%i\n", posicionActualCabezal.cylinder, posicionActualCabezal.sector);
				sectorPedido1 = ppd_LBAToCHS(pedidoPorProcesar.direccionSector);
				log_info(logger, "procesoPedido", "Sector Solicitado: %i:%i\n", sectorPedido1.cylinder, sectorPedido1.sector);
				sectores = SectoresRecorro(posicionActualCabezal, sectorPedido1);
				sectoresRecorridos = armarSectoresRecorridosLogueo(sectores, diferenciaEntreSectores(posicionActualCabezal, sectorPedido1));
				log_info(logger, "procesoPedido", "Sectores Recorridos: %s\n", sectoresRecorridos);
				log_info(logger, "procesoPedido", "Tiempo consumido: %f ms\n", tiempoEntreSectores(posicionActualCabezal, sectorPedido1));
				imprimirProximoSector();
				free(sectores);
				free(sectoresRecorridos);
				break;
			case 4:
				sectorPedido1 = ppd_LBAToCHS(colaLogueo[0]);
				sectorPedido2 = ppd_LBAToCHS(colaLogueo[1]);
				sectorPedido3 = ppd_LBAToCHS(colaLogueo[2]);
				sectorPedido4 = ppd_LBAToCHS(colaLogueo[3]);
				log_info(logger, "procesoPedido", "Cola de Pedidos: [ %i:%i, %i:%i, %i:%i, %i:%i ] Tamaño: %i\n", sectorPedido1.cylinder, sectorPedido1.sector, sectorPedido2.cylinder, sectorPedido2.sector, sectorPedido3.cylinder, sectorPedido3.sector, sectorPedido4.cylinder, sectorPedido4.sector, sizeCola);
				log_info(logger, "procesoPedido", "Posicion Actual: %i:%i\n", posicionActualCabezal.cylinder, posicionActualCabezal.sector);
				sectorPedido1 = ppd_LBAToCHS(pedidoPorProcesar.direccionSector);
				log_info(logger, "procesoPedido", "Sector Solicitado: %i:%i\n", sectorPedido1.cylinder, sectorPedido1.sector);
				sectores = SectoresRecorro(posicionActualCabezal, sectorPedido1);
				sectoresRecorridos = armarSectoresRecorridosLogueo(sectores, diferenciaEntreSectores(posicionActualCabezal, sectorPedido1));
				log_info(logger, "procesoPedido", "Sectores Recorridos: %s\n", sectoresRecorridos);
				log_info(logger, "procesoPedido", "Tiempo consumido: %f ms\n", tiempoEntreSectores(posicionActualCabezal, sectorPedido1));
				imprimirProximoSector();
				free(sectores);
				free(sectoresRecorridos);
				break;
			case 5:
				sectorPedido1 = ppd_LBAToCHS(colaLogueo[0]);
				sectorPedido2 = ppd_LBAToCHS(colaLogueo[1]);
				sectorPedido3 = ppd_LBAToCHS(colaLogueo[2]);
				sectorPedido4 = ppd_LBAToCHS(colaLogueo[3]);
				sectorPedido5 = ppd_LBAToCHS(colaLogueo[4]);
				log_info(logger, "procesoPedido", "Cola de Pedidos: [ %i:%i, %i:%i, %i:%i, %i:%i, %i:%i ] Tamaño: %i\n", sectorPedido1.cylinder, sectorPedido1.sector, sectorPedido2.cylinder, sectorPedido2.sector, sectorPedido3.cylinder, sectorPedido3.sector, sectorPedido4.cylinder, sectorPedido4.sector,sectorPedido5.cylinder, sectorPedido5.sector, sizeCola);
				log_info(logger, "procesoPedido", "Posicion Actual: %i:%i\n", posicionActualCabezal.cylinder, posicionActualCabezal.sector);
				sectorPedido1 = ppd_LBAToCHS(pedidoPorProcesar.direccionSector);
				log_info(logger, "procesoPedido", "Sector Solicitado: %i:%i\n", sectorPedido1.cylinder, sectorPedido1.sector);
				sectores = SectoresRecorro(posicionActualCabezal, sectorPedido1);
				sectoresRecorridos = armarSectoresRecorridosLogueo(sectores, diferenciaEntreSectores(posicionActualCabezal, sectorPedido1));
				log_info(logger, "procesoPedido", "Sectores Recorridos: %s\n", sectoresRecorridos);
				log_info(logger, "procesoPedido", "Tiempo consumido: %f ms\n", tiempoEntreSectores(posicionActualCabezal, sectorPedido1));
				imprimirProximoSector();
				free(sectores);
				free(sectoresRecorridos);
				break;
			case 6:
				sectorPedido1 = ppd_LBAToCHS(colaLogueo[0]);
				sectorPedido2 = ppd_LBAToCHS(colaLogueo[1]);
				sectorPedido3 = ppd_LBAToCHS(colaLogueo[2]);
				sectorPedido4 = ppd_LBAToCHS(colaLogueo[3]);
				sectorPedido5 = ppd_LBAToCHS(colaLogueo[4]);
				sectorPedido6 = ppd_LBAToCHS(colaLogueo[5]);
				log_info(logger, "procesoPedido", "Cola de Pedidos: [ %i:%i, %i:%i, %i:%i, %i:%i, %i:%i, %i:%i ] Tamaño: %i\n", sectorPedido1.cylinder, sectorPedido1.sector, sectorPedido2.cylinder, sectorPedido2.sector, sectorPedido3.cylinder, sectorPedido3.sector, sectorPedido4.cylinder, sectorPedido4.sector,sectorPedido5.cylinder, sectorPedido5.sector, sectorPedido6.cylinder, sectorPedido6.sector, sizeCola);
				log_info(logger, "procesoPedido", "Posicion Actual: %i:%i\n", posicionActualCabezal.cylinder, posicionActualCabezal.sector);
				sectorPedido1 = ppd_LBAToCHS(pedidoPorProcesar.direccionSector);
				log_info(logger, "procesoPedido", "Sector Solicitado: %i:%i\n", sectorPedido1.cylinder, sectorPedido1.sector);
				sectores = SectoresRecorro(posicionActualCabezal, sectorPedido1);
				sectoresRecorridos = armarSectoresRecorridosLogueo(sectores, diferenciaEntreSectores(posicionActualCabezal, sectorPedido1));
				log_info(logger, "procesoPedido", "Sectores Recorridos: %s\n", sectoresRecorridos);
				log_info(logger, "procesoPedido", "Tiempo consumido: %f ms\n", tiempoEntreSectores(posicionActualCabezal, sectorPedido1));
				imprimirProximoSector();
				free(sectores);
				free(sectoresRecorridos);
				break;
			default :
				sectorPedido1 = ppd_LBAToCHS(colaLogueo[0]);
				sectorPedido2 = ppd_LBAToCHS(colaLogueo[1]);
				sectorPedido3 = ppd_LBAToCHS(colaLogueo[2]);
				sectorPedido4 = ppd_LBAToCHS(colaLogueo[3]);
				sectorPedido5 = ppd_LBAToCHS(colaLogueo[4]);
				sectorPedido6 = ppd_LBAToCHS(colaLogueo[5]);
				log_info(logger, "procesoPedido", "Cola de Pedidos: [ %i:%i, %i:%i, %i:%i ...  %i:%i, %i:%i, %i:%i ] Tamaño: %i\n", sectorPedido1.cylinder, sectorPedido1.sector, sectorPedido2.cylinder, sectorPedido2.sector, sectorPedido3.cylinder, sectorPedido3.sector, sectorPedido4.cylinder, sectorPedido4.sector,sectorPedido5.cylinder, sectorPedido5.sector, sectorPedido6.cylinder, sectorPedido6.sector, sizeCola);
				log_info(logger, "procesoPedido", "Posicion Actual: %i:%i\n", posicionActualCabezal.cylinder, posicionActualCabezal.sector);
				sectorPedido1 = ppd_LBAToCHS(pedidoPorProcesar.direccionSector);
				log_info(logger, "procesoPedido", "Sector Solicitado: %i:%i\n", sectorPedido1.cylinder, sectorPedido1.sector);
				sectores = SectoresRecorro(posicionActualCabezal, sectorPedido1);
				sectoresRecorridos = armarSectoresRecorridosLogueo(sectores, diferenciaEntreSectores(posicionActualCabezal, sectorPedido1));
				log_info(logger, "procesoPedido", "Sectores Recorridos: %s\n", sectoresRecorridos);
				log_info(logger, "procesoPedido", "Tiempo consumido: %f ms\n", tiempoEntreSectores(posicionActualCabezal, sectorPedido1));
				imprimirProximoSector();
				free(sectores);
				free(sectoresRecorridos);
				break;
			}
//			break;
//
//			case SIN_INANICION :
//				switch(sizeCola)
//				{
//				case 1 :
//					sectorPedido1 = ppd_LBAToCHS(colaLogueo[0]);
//					log_info(logger, "procesoPedido", "Cola de Pedidos: [ %i:%i ] Tamaño: %i\n", sectorPedido1.cylinder, sectorPedido1.sector, sizeListaNSTEP);
//					log_info(logger, "procesoPedido", "Posicion Actual: %i:%i\n", posicionActualCabezal.cylinder, posicionActualCabezal.sector);
//					sectorPedido1 = ppd_LBAToCHS(pedidoPorProcesar.direccionSector);
//					log_info(logger, "procesoPedido", "Sector Solicitado: %i:%i\n", sectorPedido1.cylinder, sectorPedido1.sector);
//
//					//ESTA FUNCION ME DEVUELVE UN ARRAY CON LOS SECTORES QUE RECORRO PARA LLEGAR AL SECTOR QUE SE VA A PROCESAR
//					sectores = SectoresRecorro(posicionActualCabezal, sectorPedido1);
//
//					//ESTA FUNCION CONVIERTE EL ARRAY DE INTS A CHAR* PARA SER LOGUEADO
//					sectoresRecorridos = armarSectoresRecorridosLogueo(sectores, diferenciaEntreSectores(posicionActualCabezal, sectorPedido1));
//					log_info(logger, "procesoPedido", "Sectores Recorridos: %s\n", sectoresRecorridos);
//					log_info(logger, "procesoPedido", "Tiempo consumido: %f ms\n", tiempoEntreSectores(posicionActualCabezal, sectorPedido1));
//					imprimirProximoSector();
//					free(sectores);
//					free(sectoresRecorridos);
//					break;
//
//				case 2 :
//					sectorPedido1 = ppd_LBAToCHS(colaLogueo[0]);
//					sectorPedido2 = ppd_LBAToCHS(colaLogueo[1]);
//					log_info(logger, "procesoPedido", "Cola de Pedidos: [ %i:%i, %i:%i ] Tamaño: %i\n", sectorPedido1.cylinder, sectorPedido1.sector, sectorPedido2.cylinder, sectorPedido2.sector, sizeListaNSTEP);
//					log_info(logger, "procesoPedido", "Posicion Actual: %i:%i\n", posicionActualCabezal.cylinder, posicionActualCabezal.sector);
//					sectorPedido1 = ppd_LBAToCHS(pedidoPorProcesar.direccionSector);
//					log_info(logger, "procesoPedido", "Sector Solicitado: %i:%i\n", sectorPedido1.cylinder, sectorPedido1.sector);
//					sectores = SectoresRecorro(posicionActualCabezal, sectorPedido1);
//					sectoresRecorridos = armarSectoresRecorridosLogueo(sectores, diferenciaEntreSectores(posicionActualCabezal, sectorPedido1));
//					log_info(logger, "procesoPedido", "Sectores Recorridos: %s\n", sectoresRecorridos);
//					log_info(logger, "procesoPedido", "Tiempo consumido: %f ms\n", tiempoEntreSectores(posicionActualCabezal, sectorPedido1));
//					imprimirProximoSector();
//					free(sectores);
//					free(sectoresRecorridos);
//
//					break;
//				case 3:
//					sectorPedido1 = ppd_LBAToCHS(colaLogueo[0]);
//					sectorPedido2 = ppd_LBAToCHS(colaLogueo[1]);
//					sectorPedido3 = ppd_LBAToCHS(colaLogueo[2]);
//					log_info(logger, "procesoPedido", "Cola de Pedidos: [ %i:%i, %i:%i, %i:%i ] Tamaño: %i\n", sectorPedido1.cylinder, sectorPedido1.sector, sectorPedido2.cylinder, sectorPedido2.sector, sectorPedido3.cylinder, sectorPedido3.sector, sizeListaNSTEP);
//					log_info(logger, "procesoPedido", "Posicion Actual: %i:%i\n", posicionActualCabezal.cylinder, posicionActualCabezal.sector);
//					sectorPedido1 = ppd_LBAToCHS(pedidoPorProcesar.direccionSector);
//					log_info(logger, "procesoPedido", "Sector Solicitado: %i:%i\n", sectorPedido1.cylinder, sectorPedido1.sector);
//					sectores = SectoresRecorro(posicionActualCabezal, sectorPedido1);
//					sectoresRecorridos = armarSectoresRecorridosLogueo(sectores, diferenciaEntreSectores(posicionActualCabezal, sectorPedido1));
//					log_info(logger, "procesoPedido", "Sectores Recorridos: %s\n", sectoresRecorridos);
//					log_info(logger, "procesoPedido", "Tiempo consumido: %f ms\n", tiempoEntreSectores(posicionActualCabezal, sectorPedido1));
//					imprimirProximoSector();
//					free(sectores);
//					free(sectoresRecorridos);
//					break;
//				case 4:
//					sectorPedido1 = ppd_LBAToCHS(colaLogueo[0]);
//					sectorPedido2 = ppd_LBAToCHS(colaLogueo[1]);
//					sectorPedido3 = ppd_LBAToCHS(colaLogueo[2]);
//					sectorPedido4 = ppd_LBAToCHS(colaLogueo[3]);
//					log_info(logger, "procesoPedido", "Cola de Pedidos: [ %i:%i, %i:%i, %i:%i, %i:%i ] Tamaño: %i\n", sectorPedido1.cylinder, sectorPedido1.sector, sectorPedido2.cylinder, sectorPedido2.sector, sectorPedido3.cylinder, sectorPedido3.sector, sectorPedido4.cylinder, sectorPedido4.sector, sizeListaNSTEP);
//					log_info(logger, "procesoPedido", "Posicion Actual: %i:%i\n", posicionActualCabezal.cylinder, posicionActualCabezal.sector);
//					sectorPedido1 = ppd_LBAToCHS(pedidoPorProcesar.direccionSector);
//					log_info(logger, "procesoPedido", "Sector Solicitado: %i:%i\n", sectorPedido1.cylinder, sectorPedido1.sector);
//					sectores = SectoresRecorro(posicionActualCabezal, sectorPedido1);
//					sectoresRecorridos = armarSectoresRecorridosLogueo(sectores, diferenciaEntreSectores(posicionActualCabezal, sectorPedido1));
//					log_info(logger, "procesoPedido", "Sectores Recorridos: %s\n", sectoresRecorridos);
//					log_info(logger, "procesoPedido", "Tiempo consumido: %f ms\n", tiempoEntreSectores(posicionActualCabezal, sectorPedido1));
//					imprimirProximoSector();
//					free(sectores);
//					free(sectoresRecorridos);
//					break;
//				case 5:
//					sectorPedido1 = ppd_LBAToCHS(colaLogueo[0]);
//					sectorPedido2 = ppd_LBAToCHS(colaLogueo[1]);
//					sectorPedido3 = ppd_LBAToCHS(colaLogueo[2]);
//					sectorPedido4 = ppd_LBAToCHS(colaLogueo[3]);
//					sectorPedido5 = ppd_LBAToCHS(colaLogueo[4]);
//					log_info(logger, "procesoPedido", "Cola de Pedidos: [ %i:%i, %i:%i, %i:%i, %i:%i, %i:%i ] Tamaño: %i\n", sectorPedido1.cylinder, sectorPedido1.sector, sectorPedido2.cylinder, sectorPedido2.sector, sectorPedido3.cylinder, sectorPedido3.sector, sectorPedido4.cylinder, sectorPedido4.sector,sectorPedido5.cylinder, sectorPedido5.sector, sizeListaNSTEP);
//					log_info(logger, "procesoPedido", "Posicion Actual: %i:%i\n", posicionActualCabezal.cylinder, posicionActualCabezal.sector);
//					sectorPedido1 = ppd_LBAToCHS(pedidoPorProcesar.direccionSector);
//					log_info(logger, "procesoPedido", "Sector Solicitado: %i:%i\n", sectorPedido1.cylinder, sectorPedido1.sector);
//					sectores = SectoresRecorro(posicionActualCabezal, sectorPedido1);
//					sectoresRecorridos = armarSectoresRecorridosLogueo(sectores, diferenciaEntreSectores(posicionActualCabezal, sectorPedido1));
//					log_info(logger, "procesoPedido", "Sectores Recorridos: %s\n", sectoresRecorridos);
//					log_info(logger, "procesoPedido", "Tiempo consumido: %f ms\n", tiempoEntreSectores(posicionActualCabezal, sectorPedido1));
//					imprimirProximoSector();
//					free(sectores);
//					free(sectoresRecorridos);
//					break;
//				case 6:
//					sectorPedido1 = ppd_LBAToCHS(colaLogueo[0]);
//					sectorPedido2 = ppd_LBAToCHS(colaLogueo[1]);
//					sectorPedido3 = ppd_LBAToCHS(colaLogueo[2]);
//					sectorPedido4 = ppd_LBAToCHS(colaLogueo[3]);
//					sectorPedido5 = ppd_LBAToCHS(colaLogueo[4]);
//					sectorPedido6 = ppd_LBAToCHS(colaLogueo[5]);
//					log_info(logger, "procesoPedido", "Cola de Pedidos: [ %i:%i, %i:%i, %i:%i, %i:%i, %i:%i, %i:%i ] Tamaño: %i\n", sectorPedido1.cylinder, sectorPedido1.sector, sectorPedido2.cylinder, sectorPedido2.sector, sectorPedido3.cylinder, sectorPedido3.sector, sectorPedido4.cylinder, sectorPedido4.sector,sectorPedido5.cylinder, sectorPedido5.sector, sectorPedido6.cylinder, sectorPedido6.sector, sizeListaNSTEP);
//					log_info(logger, "procesoPedido", "Posicion Actual: %i:%i\n", posicionActualCabezal.cylinder, posicionActualCabezal.sector);
//					sectorPedido1 = ppd_LBAToCHS(pedidoPorProcesar.direccionSector);
//					log_info(logger, "procesoPedido", "Sector Solicitado: %i:%i\n", sectorPedido1.cylinder, sectorPedido1.sector);
//					sectores = SectoresRecorro(posicionActualCabezal, sectorPedido1);
//					sectoresRecorridos = armarSectoresRecorridosLogueo(sectores, diferenciaEntreSectores(posicionActualCabezal, sectorPedido1));
//					log_info(logger, "procesoPedido", "Sectores Recorridos: %s\n", sectoresRecorridos);
//					log_info(logger, "procesoPedido", "Tiempo consumido: %f ms\n", tiempoEntreSectores(posicionActualCabezal, sectorPedido1));
//					imprimirProximoSector();
//					free(sectores);
//					free(sectoresRecorridos);
//					break;
//				default :
//					sectorPedido1 = ppd_LBAToCHS(colaLogueo[0]);
//					sectorPedido2 = ppd_LBAToCHS(colaLogueo[1]);
//					sectorPedido3 = ppd_LBAToCHS(colaLogueo[2]);
//					sectorPedido4 = ppd_LBAToCHS(colaLogueo[3]);
//					sectorPedido5 = ppd_LBAToCHS(colaLogueo[4]);
//					sectorPedido6 = ppd_LBAToCHS(colaLogueo[5]);
//					log_info(logger, "procesoPedido", "Cola de Pedidos: [ %i:%i, %i:%i, %i:%i ...  %i:%i, %i:%i, %i:%i ] Tamaño: %i\n", sectorPedido1.cylinder, sectorPedido1.sector, sectorPedido2.cylinder, sectorPedido2.sector, sectorPedido3.cylinder, sectorPedido3.sector, sectorPedido4.cylinder, sectorPedido4.sector,sectorPedido5.cylinder, sectorPedido5.sector, sectorPedido6.cylinder, sectorPedido6.sector, sizeListaNSTEP);
//					log_info(logger, "procesoPedido", "Posicion Actual: %i:%i\n", posicionActualCabezal.cylinder, posicionActualCabezal.sector);
//					sectorPedido1 = ppd_LBAToCHS(pedidoPorProcesar.direccionSector);
//					log_info(logger, "procesoPedido", "Sector Solicitado: %i:%i\n", sectorPedido1.cylinder, sectorPedido1.sector);
//					sectores = SectoresRecorro(posicionActualCabezal, sectorPedido1);
//					sectoresRecorridos = armarSectoresRecorridosLogueo(sectores, diferenciaEntreSectores(posicionActualCabezal, sectorPedido1));
//					log_info(logger, "procesoPedido", "Sectores Recorridos: %s\n", sectoresRecorridos);
//					log_info(logger, "procesoPedido", "Tiempo consumido: %f ms\n", tiempoEntreSectores(posicionActualCabezal, sectorPedido1));
//					imprimirProximoSector();
//					free(sectores);
//					free(sectoresRecorridos);
//					break;
//				}

		}
	}

void imprimirProximoSector()
{
	int32_t next = ppd_CHStoLBA(proximoSectorPlanifico);

	switch(next)
	{
	case -1 :
		if (configuracion.LogActivado==1){
			log_info(logger, "procesoPedido", "Proximo sector: ... \n");
		}
		break;

	default :
		if (configuracion.LogActivado==1){
			log_info(logger, "procesoPedido", "Proximo sector: %i:%i \n", proximoSectorPlanifico.cylinder, proximoSectorPlanifico.sector);
		}
		break;
	}
}

char *armarSectoresRecorridosLogueo(int32_t *ptrSectoresRecorridos, int32_t cantidadSectores)
{
	int32_t i=0;
	PPD_CHS aux;
	char auxchar[4];
	int32_t tamanioArray=0;
	int32_t caracteresEscritos;
	char *cilindro = malloc(sizeof(char)*4);
	char *sector = malloc(sizeof(char)*4);

	if(cantidadSectores < 20)
	{
		for( i=0; i<cantidadSectores; i++)
		{
			aux=ppd_LBAToCHS(ptrSectoresRecorridos[i]);
			caracteresEscritos=sprintf(auxchar,"%d",aux.cylinder);
			tamanioArray=tamanioArray+caracteresEscritos;
			tamanioArray=tamanioArray+strlen(":");
			caracteresEscritos=sprintf(auxchar,"%d",aux.sector);
			tamanioArray=tamanioArray+caracteresEscritos;
			tamanioArray=tamanioArray+strlen(" ");
		}
	}
	else
	{
		for( i=0; i<20; i++)
		{
			aux=ppd_LBAToCHS(ptrSectoresRecorridos[i]);
			caracteresEscritos=sprintf(auxchar,"%d",aux.cylinder);
			tamanioArray=tamanioArray+caracteresEscritos;
			tamanioArray=tamanioArray+strlen(":");
			caracteresEscritos=sprintf(auxchar,"%d",aux.sector);
			tamanioArray=tamanioArray+caracteresEscritos;
			tamanioArray=tamanioArray+strlen(" ")+strlen("... ");
		}
	}

	sectoresRecorridos = (char*)malloc(tamanioArray+5);

	//LIMPIO LA MEMORIA
	for (i= 0 ; i< tamanioArray; i++)
	{
		sectoresRecorridos[i]='\0';
	}

	//PREGUNTO SI LA CANTIDAD ES MENOR O IGUAL A 20, RECORRO DIRECTO, SINO RECORRO LOS PRIMEROS 10 Y LOS ULTIMOS 10
	if(cantidadSectores<=20)
	{
		if (cantidadSectores == 0)
		{
			strcpy(sectoresRecorridos, "...");
			return sectoresRecorridos;
		}

		for (i = 0; i<cantidadSectores;i++)
		{
			PPD_CHS sectorCargo;
			sectorCargo = ppd_LBAToCHS(ptrSectoresRecorridos[i]);
			sprintf(cilindro, "%d", sectorCargo.cylinder);
			sprintf(sector, "%d", sectorCargo.sector);
			strcat(sectoresRecorridos, cilindro);
			strcat(sectoresRecorridos, ":");
			strcat(sectoresRecorridos, sector);
			strcat(sectoresRecorridos, " ");
		}
	}
	else
	{
		for (i = 0; i<10;i++)
		{
			PPD_CHS sectorCargo;
			sectorCargo = ppd_LBAToCHS(ptrSectoresRecorridos[i]);
			sprintf(cilindro, "%d", sectorCargo.cylinder);
			sprintf(sector, "%d", sectorCargo.sector);
			strcat(sectoresRecorridos, cilindro);
			strcat(sectoresRecorridos, ":");
			strcat(sectoresRecorridos, sector);
			strcat(sectoresRecorridos, " ");
		}

		strcat(sectoresRecorridos, "... ");

		for(i = cantidadSectores-10; i < cantidadSectores; i++)
		{
			PPD_CHS sectorCargo;
			sectorCargo = ppd_LBAToCHS(ptrSectoresRecorridos[i]);
			sprintf(cilindro, "%d", sectorCargo.cylinder);
			sprintf(sector, "%d", sectorCargo.sector);
			strcat(sectoresRecorridos, cilindro);
			strcat(sectoresRecorridos, ":");
			strcat(sectoresRecorridos, sector);
			strcat(sectoresRecorridos, " ");
		}
	}

	free(sector);
	free(cilindro);
	return sectoresRecorridos;
}




void agarroNPedidos(t_nodoCola ** listaNATrabajar1,int32_t *J){

	*listaNATrabajar1 = colaPedidos->frente;
	t_nodoCola * aux = NULL;
	aux = colaPedidos->frente;
	(*J) = 0;
	int32_t var1;
	for (var1 = 1; var1 <= configuracion.tamanioListaScan; var1++) {

		if(aux != NULL){

			aux = aux->siguiente;
			(*J)++;
		}

	}

	//aux->siguiente = NULL;

}
